package lock8;

import java.util.concurrent.TimeUnit;
/**
 * 8锁，就是关于锁的8个问题
 * 3、增加一个普通方法后，先执行发短信还是Hello？先Hello再发短信
 * 4、两个对象，两个同步方法，先发短信还是先打电话？  两个对象 两个调用者，两把锁；所以都可以拿到锁，但是短信延迟了4秒，所以先打电话再发短信
 * 5、增加两个静态的同步方法，先发短信还是先打电话？静态方法，类一加载的就有了，锁的是Class，类只有一个模板，所以谁先拿到锁谁先执行
 * 6、两个对象，增加两个静态同步方法，先发短信还是先打电话？ 两个对象的class类模板只有一个，static，锁的是class。所以谁先拿到锁谁先执行
 * 7、1个静态同步方法，1个普通的同步方法，一个对象，先发短信还是先打电话？先打电话再发短信，因为static锁的是类模板，普通同步方法锁的是方法的调用者，所以两个锁的对象不一样，都可以拿到锁。A创建线程的时候过了1秒B再创建，但是A要延迟4秒才调用了短信，所以这里1秒之后创建了线程B调用打电话方法直接输出打电话，然后过了几秒后才发短信。
 * 8、1个静态同步方法，1个普通的同步方法，两个对象，先发短信还是先打电话？先打电话再发短信，因为static锁的是类模板，普通同步方法锁的是方法的调用者，所以两个锁的对象不一样，都可以拿到锁。A创建线程的时候过了1秒B再创建，但是A要延迟4秒才调用了短信，所以这里1秒之后创建了线程B调用打电话方法直接输出打电话，然后过了几秒后才发短信。
 */

public class Test4 {
    public static void main(String[] args) {
//        两个对象的class类模板只有一个，static，锁的是class。
        Phone4 phone = new Phone4();
        Phone4 phone2 = new Phone4();

//        锁的存在
        new Thread(()->{
            phone.sendSms();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone2.call();
        },"B").start();
    }
}
//Phone3唯一的一个class对象
class Phone4 {
    //    静态同步方法，类一加载的就有了，锁的是Class类模板
    public static synchronized void sendSms()  {

        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");


    }
//    普通同步方法
    public  synchronized void call(){
        System.out.println("打电话");

    }


}

/*
打电话
发短信
 */